home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / pascal / tjoop11.zip / STACKOBJ.PAS < prev    next >
Pascal/Delphi Source File  |  1991-05-17  |  5KB  |  183 lines
  1. UNIT StackOBJ ;
  2.  
  3.  
  4.  
  5.  
  6. {**********************************************************************
  7.  *                                                                    *
  8.  *  PROGRAM :  StackOBJ                PC FILE NAME :  STACKOBJ.PAS   *
  9.  *  ----------------------------------------------------------------  *
  10.  *  LIBRARY MODULES USED :  DOS CRT                                   *
  11.  *  BaseType :  TP6.0 TPU SOURCE: BASETYPE.PAS  BINARY:  BASETYPE.TPU *
  12.  *  ----------------------------------------------------------------  *
  13.  *  PURPOSE :  The purpose of this UNIT is to provide a Stack Object  *
  14.  *             with basic functionality.                              *
  15.  *  ----------------------------------------------------------------  *
  16.  *  AUTHOR   :  Thomas E. Jenkins, Jr.                                *
  17.  *              PROGRAMMER, UNIVERSITY OF SOUTH CAROLINA, USA         *
  18.  *  BITNET   :  C0361@UNIVSCVM.BITNET                                 *
  19.  *  INTERNET :  C0361@univscvm.csd.scarolina.EDU                      *
  20.  *              tomj@csdserver3.csd.scarolina.EDU                     *
  21.  *  ----------------------------------------------------------------  *
  22.  *  DISCAIMER :  This program has been tested to the best of my       *
  23.  *               abilities.  The author claims no responsibility      *
  24.  *               for the performance or side effects this program     *
  25.  *               may yield.                                           *
  26.  *  ----------------------------------------------------------------  *
  27.  *  DISTIBUTION :  This program is given freely to the PD realms.     *
  28.  *                 It may freely be copied and distributed.  Any      *
  29.  *                 one wishing to use some or whole parts of this     *
  30.  *                 program for commercial use please contact the      *
  31.  *                 author first.                                      *
  32.  *                                                                    *
  33.  **********************************************************************}
  34.  
  35.  
  36.  
  37.  
  38.                                   INTERFACE
  39.  
  40.  
  41.  
  42.  
  43.  
  44.  
  45.              {
  46.  
  47.  
  48.                  Here is a basic view of the Stack object tree:
  49.  
  50.                  TObject                    [ to allow use with streams   ]
  51.                     |
  52.                     |
  53.                     \___ TBaseOBJ           [ basic functions of stack &  ]
  54.                              |              [ elements                    ]
  55.                              |
  56.                              \___ TElementOBJ    [ basic functionality of ]
  57.                              /         |         [ any element            ]
  58.                              |         |
  59.                              |         \___ TStrOBJ [ string specific     ]
  60.                              |         /            [ functions & storage ]
  61.                              |         |
  62.                              |         |
  63.                              |         \___ TIntOBJ [ integer specific    ]
  64.                              |         /            [ functions & storage ]
  65.                              |         |
  66.                              |         |
  67.                              |         \___ TRealOBJ [ real specific      ]
  68.                              |                       [ functions & storage]
  69.                              |
  70.                              \___ TStackOBJ      [ stack specific         ]
  71.                                                  [ functions & storage    ]
  72.  
  73.              }
  74.  
  75.  
  76. USES
  77.        BaseTypes ;                  {  For the base TYPE TBaseOBJ  }
  78.                                     {  and TElementOBJ             }
  79.  
  80.  
  81.  
  82.  
  83. TYPE
  84.  
  85.        PStackOBJ                       = ^TStackOBJ ;
  86.        TStackOBJ                       = OBJECT ( TBaseOBJ )
  87.  
  88.          stack                                   : PElementOBJ ;
  89.  
  90.          CONSTRUCTOR Init ;
  91.  
  92.          PROCEDURE   Push (     item             : PElementOBJ ) ;
  93.            VIRTUAL ;
  94.  
  95.          FUNCTION    Pop                         : PElementOBJ ;
  96.            VIRTUAL ;
  97.  
  98.          FUNCTION    Empty                       : BOOLEAN ;
  99.            VIRTUAL ;
  100.  
  101.          DESTRUCTOR  Done ;
  102.            VIRTUAL ;
  103.  
  104.          END ;  {  TStackOBJ  }
  105.  
  106.  
  107.  
  108.  
  109.                                 IMPLEMENTATION
  110.  
  111.  
  112.  
  113.  
  114.  CONSTRUCTOR TStackOBJ.Init ;
  115.  
  116.    BEGIN  {  TStackOBJ.Init  }
  117.  
  118.      stack := NIL ;
  119.  
  120.      END ;  {  TStackOBJ.Init  }
  121.  
  122.  
  123.  
  124.  
  125.  PROCEDURE   TStackOBJ.Push (     item           : PElementOBJ ) ;
  126.  
  127.   BEGIN  {  TStackOBJ.Push  }
  128.  
  129.     item^.last := stack ;
  130.  
  131.     stack := item ;
  132.  
  133.     END ;  {  TStackOBJ.Push  }
  134.  
  135.  
  136.  
  137.  
  138.  FUNCTION    TStackOBJ.Pop                       : PElementOBJ ;
  139.  
  140.   BEGIN  {  TStackOBJ.Pop  }
  141.  
  142.     Pop := stack ;
  143.  
  144.     IF ( Empty )
  145.      THEN
  146.         Exit ;
  147.  
  148.     stack := stack^.last ;
  149.  
  150.     END ;  {  TStackOBJ.Pop  }
  151.  
  152.  
  153.  
  154.  
  155.  FUNCTION    TStackOBJ.Empty                     : BOOLEAN ;
  156.  
  157.   BEGIN  {  TStackOBJ.Empty  }
  158.  
  159.     Empty := ( stack = NIL ) ;
  160.  
  161.     END ;  {  TStackOBJ.Empty  }
  162.  
  163.  
  164.  
  165.  
  166.  DESTRUCTOR  TStackOBJ.Done ;
  167.  
  168.    BEGIN  {  TStackOBJ.Done  }
  169.  
  170.      WHILE ( stack <> NIL )
  171.       DO
  172.        BEGIN
  173.  
  174.          Dispose ( Pop , Done ) ;
  175.  
  176.          END ;  {  WHILE  }
  177.  
  178.      END ;  {  TStackOBJ.Done  }
  179.  
  180.  
  181.  
  182.  
  183. END .